package com.example.learningnote.views;

import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.TextView;

import androidx.annotation.NonNull;
import androidx.fragment.app.Fragment;

import com.example.learningnote.R;
import com.example.learningnote.params.LoginParams;
import com.example.learningnote.response.UserResponse;
import com.example.learningnote.apis.LoginApi;
import com.example.learningnote.utils.Memory;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 三种异步的方式
// Handler  是 Android 提供的消息处理机制，用于在线程间通信，特别是在主线程（UI 线程）与其他线程之间传递数据。
//      新线程（new Thread）中执行网络请求，通过 Handler.sendMessage 将结果（Message）发送到主线程的 Looper 消息队列。
//      Looper：每个线程有一个消息队列，Looper.getMainLooper() 获取主线程的循环器。
//      Message：封装数据（如 UserResponse 或错误信息），通过 msg.what 区分类型。
//      Handler：绑定到 Looper，负责发送和处理消息。
// AsyncTask 是 Android 提供的简化异步任务的工具，内置线程池管理，适合简单的后台任务（如网络请求）
//      doInBackground：在后台线程执行耗时任务（如 fetchLoginAsync）。
//      onPostExecute：在主线程处理结果，更新 UI。
//      execute：启动任务，调度到线程池。
// ExecutorService 是线程池管理工具，用于执行异步任务
//      Executors.newSingleThreadExecutor() 创建单线程池，保证任务顺序执行。
//      executor.execute 在子线程运行 fetchLoginAsync。
//      handler.post 将结果处理逻辑调度到主线程。
//      Handler 用于将子线程的结果传递到主线程，更新 UI。

// handler.post 的作用
//      将一个 Runnable 任务提交到 Handler 绑定的 Looper 消息队列，任务会在关联线程（通常是主线程）执行。
//      直接运行 UI 更新代码，减少使用sendMessage 传递复杂数据

// 推荐使用 显式定义线程池（ExecutorService）和主线程调度（handler.post）。
// ExecutorService 提供线程池，复用线程，减少创建/销毁线程的开销
// new Thread 每次创建新线程，性能开销大，适合一次性任务。
// ExecutorService 支持多种线程池配置（如固定大小、缓存线程池），可根据需求优化。
// 可通过 shutdown 或 submit 控制任务生命周期，防止资源泄漏。

// Executors.newSingleThreadExecutor()：
// 创建单线程池，任务按提交顺序执行。
// 适合需要顺序执行的任务（如你的登录请求）。
// Executors.newFixedThreadPool(int n)：
// 创建固定大小的线程池（n 个线程），适合并发任务。
// 示例：Executors.newFixedThreadPool(3) 支持 3 个任务同时运行。
// Executors.newCachedThreadPool()：
// 创建可缓存的线程池，动态调整线程数，适合大量短期任务。
// 注意：可能创建过多线程，需监控资源使用。
// execute(Runnable task)：
// 提交任务到线程池，无返回值。
// 你的代码中使用：executor.execute(() -> { ... })。
// submit(Callable<T> task)：
// 提交任务，返回 Future<T>，可获取结果或异常。

// newSingleThreadExecutor 适合顺序任务。
// newFixedThreadPool 适合固定并发。
// newCachedThreadPool 适合短任务，避免长期占用。


public class LoginFragment extends Fragment {
    private TextView statusTextView;
    private Handler handler;
    private final ExecutorService executor = Executors.newSingleThreadExecutor();

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_login, container, false);

        Button handlerButton = view.findViewById(R.id.login_btn_handler);
        Button asyncButton = view.findViewById(R.id.login_btn_async);
        Button execButton = view.findViewById(R.id.login_btn_exec);
        statusTextView = view.findViewById(R.id.login_status);


        // Handler 方式登录
        handlerButton.setOnClickListener(v -> {
            statusTextView.setText("正在加载中 (Handler)...");
            LoginParams params = new LoginParams("hmheima", "Hmheima%123");
            LoginApi.fetchLoginHandle(params, getContext(), handler);
        });

        // AsyncTask 方式登录
        asyncButton.setOnClickListener(v -> {
            statusTextView.setText("正在加载中 (AsyncTask)...");
            LoginParams params = new LoginParams("hmheima", "Hmheima%123");
            new LoginAsyncTask().execute(params);
        });

        // ExecutorService + Handler  线程池 + Handler通信
        execButton.setOnClickListener(v -> {
            statusTextView.setText("正在加载中 (Executor)...");
            LoginParams params = new LoginParams("hmheima", "Hmheima%123");
            if (getContext() != null) {
                executor.execute(() -> {
                    LoginApi.LoginResult result = LoginApi.fetchLoginAsync(params, getContext());
                    new Handler(Looper.getMainLooper()).post(() -> {
                        UserInfoFragment userInfoFragment = (UserInfoFragment) getParentFragmentManager().findFragmentById(R.id.user_info_fragment);
                        if (userInfoFragment != null) {
                            if (result.isSuccess()) {
                                statusTextView.setText("登录成功 (Executor)");
                                userInfoFragment.updateUserInfo(result.getUserResponse());
                                Memory.getInstance(getContext()).set("access_token", result.getUserResponse().getToken());
                            } else {
                                statusTextView.setText("登录失败 (Executor)");
                                userInfoFragment.showError("登录失败: " + result.getError());
                            }
                        }
                    });
                });
            }
        });

        handler = new Handler(Looper.getMainLooper()){
            @Override
            public void handleMessage(@NonNull Message msg) {
                UserInfoFragment userInfoFragment = (UserInfoFragment) getParentFragmentManager().findFragmentById(R.id.user_info_fragment);
                if (msg.what == 1) {
                    statusTextView.setText("登录成功 (Handler)");
                    UserResponse userResponse = (UserResponse) msg.obj;
                    Log.d("HTTP", "登录: " + userResponse);
                    userInfoFragment.updateUserInfo(userResponse);
                } else {
                    statusTextView.setText("登录失败 (Hanlder)");
                    String error = (String) msg.obj;
                    userInfoFragment.showError("登陆失败: " + error);
                }
            }
        };

        return view;
    }

    private class LoginAsyncTask extends AsyncTask<LoginParams, Void, LoginApi.LoginResult> {
        @Override
        protected LoginApi.LoginResult doInBackground(LoginParams... params) {
            return LoginApi.fetchLoginAsync(params[0], getContext());
        }
        @Override
        protected void onPostExecute(LoginApi.LoginResult result) {
            UserInfoFragment userInfoFragment = (UserInfoFragment) getParentFragmentManager().findFragmentById(R.id.user_info_fragment);
            if (userInfoFragment != null) {
                if (result.isSuccess()) {
                    statusTextView.setText("登录成功 (AsyncTask)");
                    userInfoFragment.updateUserInfo(result.getUserResponse());
                } else {
                    statusTextView.setText("登录失败 (AsyncTask)");
                    userInfoFragment.showError("登录失败: " + result.getError());
                }
            }
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        // 关闭线程池
        executor.shutdown();
    }
}

